{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Fully-Connected Neural Nets\n",
    "In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a `forward` and a `backward` function. The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:\n",
    "\n",
    "```python\n",
    "def layer_forward(x, w):\n",
    "  \"\"\" Receive inputs x and weights w \"\"\"\n",
    "  # Do some computations ...\n",
    "  z = # ... some intermediate value\n",
    "  # Do some more computations ...\n",
    "  out = # the output\n",
    "   \n",
    "  cache = (x, w, z, out) # Values we need to compute gradients\n",
    "   \n",
    "  return out, cache\n",
    "```\n",
    "\n",
    "The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:\n",
    "\n",
    "```python\n",
    "def layer_backward(dout, cache):\n",
    "  \"\"\"\n",
    "  Receive dout (derivative of loss with respect to outputs) and cache,\n",
    "  and compute derivative with respect to inputs.\n",
    "  \"\"\"\n",
    "  # Unpack cache values\n",
    "  x, w, z, out = cache\n",
    "  \n",
    "  # Use values in cache to compute derivatives\n",
    "  dx = # Derivative of loss with respect to x\n",
    "  dw = # Derivative of loss with respect to w\n",
    "  \n",
    "  return dx, dw\n",
    "```\n",
    "\n",
    "After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.\n",
    "\n",
    "In addition to implementing fully-connected networks of arbitrary depth, we will also explore different update rules for optimization, and introduce Dropout as a regularizer and Batch/Layer Normalization as a tool to more efficiently optimize deep networks.\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "  \"\"\" returns relative error \"\"\"\n",
    "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('X_train: ', (49000, 3, 32, 32))\n",
      "('y_train: ', (49000,))\n",
      "('X_val: ', (1000, 3, 32, 32))\n",
      "('y_val: ', (1000,))\n",
      "('X_test: ', (1000, 3, 32, 32))\n",
      "('y_test: ', (1000,))\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in list(data.items()):\n",
    "  print(('%s: ' % k, v.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: foward\n",
    "Open the file `cs231n/layers.py` and implement the `affine_forward` function.\n",
    "\n",
    "Once you are done you can test your implementaion by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_forward function:\n",
      "difference:  9.769849468192957e-10\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_forward function\n",
    "\n",
    "num_inputs = 2\n",
    "input_shape = (4, 5, 6)\n",
    "output_dim = 3\n",
    "\n",
    "input_size = num_inputs * np.prod(input_shape)\n",
    "weight_size = output_dim * np.prod(input_shape)\n",
    "\n",
    "x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)\n",
    "w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)\n",
    "b = np.linspace(-0.3, 0.1, num=output_dim)\n",
    "\n",
    "out, _ = affine_forward(x, w, b)\n",
    "correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n",
    "                        [ 3.25553199,  3.5141327,   3.77273342]])\n",
    "\n",
    "# Compare your output with ours. The error should be around e-9 or less.\n",
    "print('Testing affine_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: backward\n",
    "Now implement the `affine_backward` function and test your implementation using numeric gradient checking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_backward function:\n",
      "dx error:  5.399100368651805e-11\n",
      "dw error:  9.904211865398145e-11\n",
      "db error:  2.4122867568119087e-11\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_backward function\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 2, 3)\n",
    "w = np.random.randn(6, 5)\n",
    "b = np.random.randn(5)\n",
    "dout = np.random.randn(10, 5)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "_, cache = affine_forward(x, w, b)\n",
    "dx, dw, db = affine_backward(dout, cache)\n",
    "\n",
    "# The error should be around e-10 or less\n",
    "print('Testing affine_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: forward\n",
    "Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_forward function:\n",
      "difference:  4.999999798022158e-08\n"
     ]
    }
   ],
   "source": [
    "# Test the relu_forward function\n",
    "\n",
    "x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n",
    "\n",
    "out, _ = relu_forward(x)\n",
    "correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n",
    "                        [ 0.,          0.,          0.04545455,  0.13636364,],\n",
    "                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n",
    "\n",
    "# Compare your output with ours. The error should be on the order of e-8\n",
    "print('Testing relu_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: backward\n",
    "Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_backward function:\n",
      "dx error:  3.2756349136310288e-12\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 10)\n",
    "dout = np.random.randn(*x.shape)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n",
    "\n",
    "_, cache = relu_forward(x)\n",
    "dx = relu_backward(dout, cache)\n",
    "\n",
    "# The error should be on the order of e-12\n",
    "print('Testing relu_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 1: \n",
    "\n",
    "We've only asked you to implement ReLU, but there are a number of different activation functions that one could use in neural networks, each with its pros and cons. In particular, an issue commonly seen with activation functions is getting zero (or close to zero) gradient flow during backpropagation. Which of the following activation functions have this problem? If you consider these functions in the one dimensional case, what types of input would lead to this behaviour?\n",
    "1. Sigmoid\n",
    "2. ReLU\n",
    "3. Leaky ReLU\n",
    "\n",
    "## Answer:\n",
    "- Sigmoid在x过大和过小的时候梯度几乎为0\n",
    "- ReLu在x小于0 的时候梯度为0\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Sandwich\" layers\n",
    "There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file `cs231n/layer_utils.py`.\n",
    "\n",
    "For now take a look at the `affine_relu_forward` and `affine_relu_backward` functions, and run the following to numerically gradient check the backward pass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_relu_forward and affine_relu_backward:\n",
      "dx error:  2.299579177309368e-11\n",
      "dw error:  8.162011105764925e-11\n",
      "db error:  7.826724021458994e-12\n"
     ]
    }
   ],
   "source": [
    "from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(2, 3, 4)\n",
    "w = np.random.randn(12, 10)\n",
    "b = np.random.randn(10)\n",
    "dout = np.random.randn(2, 10)\n",
    "\n",
    "out, cache = affine_relu_forward(x, w, b)\n",
    "dx, dw, db = affine_relu_backward(dout, cache)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "# Relative error should be around e-10 or less\n",
    "print('Testing affine_relu_forward and affine_relu_backward:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss layers: Softmax and SVM\n",
    "You implemented these loss functions in the last assignment, so we'll give them to you for free here. You should still make sure you understand how they work by looking at the implementations in `cs231n/layers.py`.\n",
    "\n",
    "You can make sure that the implementations are correct by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing svm_loss:\n",
      "loss:  8.999602749096233\n",
      "dx error:  1.4021566006651672e-09\n",
      "\n",
      "Testing softmax_loss:\n",
      "loss:  2.302545844500738\n",
      "dx error:  9.384673161989355e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "num_classes, num_inputs = 10, 50\n",
    "x = 0.001 * np.random.randn(num_inputs, num_classes)\n",
    "y = np.random.randint(num_classes, size=num_inputs)\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = svm_loss(x, y)\n",
    "\n",
    "# Test svm_loss function. Loss should be around 9 and dx error should be around the order of e-9\n",
    "print('Testing svm_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = softmax_loss(x, y)\n",
    "\n",
    "# Test softmax_loss function. Loss should be close to 2.3 and dx error should be around e-8\n",
    "print('\\nTesting softmax_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Two-layer network\n",
    "In the previous assignment you implemented a two-layer neural network in a single monolithic class. Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.\n",
    "\n",
    "Open the file `cs231n/classifiers/fc_net.py` and complete the implementation of the `TwoLayerNet` class. This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. You can run the cell below to test your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing initialization ... \n",
      "Testing test-time forward pass ... \n",
      "Testing training loss (no regularization)\n",
      "Running numeric gradient check with reg =  0.0\n",
      "W1 relative error: 1.83e-08\n",
      "W2 relative error: 3.12e-10\n",
      "b1 relative error: 9.83e-09\n",
      "b2 relative error: 4.33e-10\n",
      "Running numeric gradient check with reg =  0.7\n",
      "W1 relative error: 2.53e-07\n",
      "W2 relative error: 2.85e-08\n",
      "b1 relative error: 1.56e-08\n",
      "b2 relative error: 7.76e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H, C = 3, 5, 50, 7\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=N)\n",
    "\n",
    "std = 1e-3\n",
    "model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n",
    "\n",
    "print('Testing initialization ... ')\n",
    "W1_std = abs(model.params['W1'].std() - std)\n",
    "b1 = model.params['b1']\n",
    "W2_std = abs(model.params['W2'].std() - std)\n",
    "b2 = model.params['b2']\n",
    "assert W1_std < std / 10, 'First layer weights do not seem right'\n",
    "assert np.all(b1 == 0), 'First layer biases do not seem right'\n",
    "assert W2_std < std / 10, 'Second layer weights do not seem right'\n",
    "assert np.all(b2 == 0), 'Second layer biases do not seem right'\n",
    "\n",
    "print('Testing test-time forward pass ... ')\n",
    "model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n",
    "model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n",
    "model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n",
    "model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n",
    "X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n",
    "scores = model.loss(X)\n",
    "correct_scores = np.asarray(\n",
    "  [[11.53165108,  12.2917344,   13.05181771,  13.81190102,  14.57198434, 15.33206765,  16.09215096],\n",
    "   [12.05769098,  12.74614105,  13.43459113,  14.1230412,   14.81149128, 15.49994135,  16.18839143],\n",
    "   [12.58373087,  13.20054771,  13.81736455,  14.43418138,  15.05099822, 15.66781506,  16.2846319 ]])\n",
    "scores_diff = np.abs(scores - correct_scores).sum()\n",
    "assert scores_diff < 1e-6, 'Problem with test-time forward pass'\n",
    "\n",
    "print('Testing training loss (no regularization)')\n",
    "y = np.asarray([0, 5, 1])\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 3.4702243556\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'\n",
    "\n",
    "model.reg = 1.0\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 26.5948426952\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'\n",
    "\n",
    "# Errors should be around e-7 or less\n",
    "for reg in [0.0, 0.7]:\n",
    "  print('Running numeric gradient check with reg = ', reg)\n",
    "  model.reg = reg\n",
    "  loss, grads = model.loss(X, y)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solver\n",
    "In the previous assignment, the logic for training models was coupled to the models themselves. Following a more modular design, for this assignment we have split the logic for training models into a separate class.\n",
    "\n",
    "Open the file `cs231n/solver.py` and read through it to familiarize yourself with the API. After doing so, use a `Solver` instance to train a `TwoLayerNet` that achieves at least `50%` accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 4900) loss: 2.304060\n",
      "(Epoch 0 / 10) train acc: 0.116000; val_acc: 0.094000\n",
      "(Iteration 101 / 4900) loss: 1.829613\n",
      "(Iteration 201 / 4900) loss: 1.857390\n",
      "(Iteration 301 / 4900) loss: 1.744448\n",
      "(Iteration 401 / 4900) loss: 1.420187\n",
      "(Epoch 1 / 10) train acc: 0.407000; val_acc: 0.422000\n",
      "(Iteration 501 / 4900) loss: 1.565913\n",
      "(Iteration 601 / 4900) loss: 1.700510\n",
      "(Iteration 701 / 4900) loss: 1.732213\n",
      "(Iteration 801 / 4900) loss: 1.688361\n",
      "(Iteration 901 / 4900) loss: 1.439529\n",
      "(Epoch 2 / 10) train acc: 0.497000; val_acc: 0.468000\n",
      "(Iteration 1001 / 4900) loss: 1.385772\n",
      "(Iteration 1101 / 4900) loss: 1.278401\n",
      "(Iteration 1201 / 4900) loss: 1.641580\n",
      "(Iteration 1301 / 4900) loss: 1.438847\n",
      "(Iteration 1401 / 4900) loss: 1.172536\n",
      "(Epoch 3 / 10) train acc: 0.490000; val_acc: 0.466000\n",
      "(Iteration 1501 / 4900) loss: 1.346286\n",
      "(Iteration 1601 / 4900) loss: 1.268492\n",
      "(Iteration 1701 / 4900) loss: 1.318215\n",
      "(Iteration 1801 / 4900) loss: 1.395750\n",
      "(Iteration 1901 / 4900) loss: 1.338233\n",
      "(Epoch 4 / 10) train acc: 0.532000; val_acc: 0.497000\n",
      "(Iteration 2001 / 4900) loss: 1.343165\n",
      "(Iteration 2101 / 4900) loss: 1.393173\n",
      "(Iteration 2201 / 4900) loss: 1.276734\n",
      "(Iteration 2301 / 4900) loss: 1.287951\n",
      "(Iteration 2401 / 4900) loss: 1.352778\n",
      "(Epoch 5 / 10) train acc: 0.525000; val_acc: 0.475000\n",
      "(Iteration 2501 / 4900) loss: 1.390234\n",
      "(Iteration 2601 / 4900) loss: 1.276361\n",
      "(Iteration 2701 / 4900) loss: 1.111768\n",
      "(Iteration 2801 / 4900) loss: 1.271688\n",
      "(Iteration 2901 / 4900) loss: 1.272039\n",
      "(Epoch 6 / 10) train acc: 0.546000; val_acc: 0.509000\n",
      "(Iteration 3001 / 4900) loss: 1.304489\n",
      "(Iteration 3101 / 4900) loss: 1.346667\n",
      "(Iteration 3201 / 4900) loss: 1.325510\n",
      "(Iteration 3301 / 4900) loss: 1.392728\n",
      "(Iteration 3401 / 4900) loss: 1.402001\n",
      "(Epoch 7 / 10) train acc: 0.567000; val_acc: 0.505000\n",
      "(Iteration 3501 / 4900) loss: 1.319024\n",
      "(Iteration 3601 / 4900) loss: 1.153287\n",
      "(Iteration 3701 / 4900) loss: 1.180922\n",
      "(Iteration 3801 / 4900) loss: 1.093164\n",
      "(Iteration 3901 / 4900) loss: 1.135902\n",
      "(Epoch 8 / 10) train acc: 0.568000; val_acc: 0.490000\n",
      "(Iteration 4001 / 4900) loss: 1.191735\n",
      "(Iteration 4101 / 4900) loss: 1.359396\n",
      "(Iteration 4201 / 4900) loss: 1.227283\n",
      "(Iteration 4301 / 4900) loss: 1.024113\n",
      "(Iteration 4401 / 4900) loss: 1.327583\n",
      "(Epoch 9 / 10) train acc: 0.592000; val_acc: 0.504000\n",
      "(Iteration 4501 / 4900) loss: 0.963330\n",
      "(Iteration 4601 / 4900) loss: 1.445619\n",
      "(Iteration 4701 / 4900) loss: 1.007542\n",
      "(Iteration 4801 / 4900) loss: 1.005175\n",
      "(Epoch 10 / 10) train acc: 0.611000; val_acc: 0.512000\n"
     ]
    }
   ],
   "source": [
    "model = TwoLayerNet()\n",
    "solver = None\n",
    "\n",
    "##############################################################################\n",
    "# TODO: Use a Solver instance to train a TwoLayerNet that achieves at least  #\n",
    "# 50% accuracy on the validation set.                                        #\n",
    "##############################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "solver = Solver(model, data,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': 1e-3,\n",
    "                },\n",
    "                lr_decay=0.95,\n",
    "                num_epochs=10, batch_size=100,\n",
    "                print_every=100)\n",
    "solver.train()\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "##############################################################################\n",
    "#                             END OF YOUR CODE                               #\n",
    "##############################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to visualize training loss and train / val accuracy\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.title('Accuracy')\n",
    "plt.plot(solver.train_acc_history, '-o', label='train')\n",
    "plt.plot(solver.val_acc_history, '-o', label='val')\n",
    "plt.plot([0.5] * len(solver.val_acc_history), 'k--')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(loc='lower right')\n",
    "plt.gcf().set_size_inches(15, 12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multilayer network\n",
    "Next you will implement a fully-connected network with an arbitrary number of hidden layers.\n",
    "\n",
    "Read through the `FullyConnectedNet` class in the file `cs231n/classifiers/fc_net.py`.\n",
    "\n",
    "Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch/layer normalization; we will add those features soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial loss and gradient check\n",
    "\n",
    "As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?\n",
    "\n",
    "For gradient checking, you should expect to see errors around 1e-7 or less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.3004790897684924\n",
      "W1 relative error: 1.48e-07\n",
      "W2 relative error: 2.21e-05\n",
      "W3 relative error: 3.53e-07\n",
      "b1 relative error: 5.38e-09\n",
      "b2 relative error: 2.09e-09\n",
      "b3 relative error: 5.80e-11\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  7.052114776533016\n",
      "W1 relative error: 3.90e-09\n",
      "W2 relative error: 6.87e-08\n",
      "W3 relative error: 2.13e-08\n",
      "b1 relative error: 1.48e-08\n",
      "b2 relative error: 1.72e-09\n",
      "b3 relative error: 1.57e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "for reg in [0, 3.14]:\n",
    "  print('Running check with reg = ', reg)\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64)\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print('Initial loss: ', loss)\n",
    "  \n",
    "  # Most of the errors should be on the order of e-7 or smaller.   \n",
    "  # NOTE: It is fine however to see an error for W2 on the order of e-5\n",
    "  # for the check when reg = 0.0\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. In the following cell, tweak the **learning rate** and **weight initialization scale** to overfit and achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 276.679212\n",
      "(Epoch 0 / 20) train acc: 0.180000; val_acc: 0.121000\n",
      "(Epoch 1 / 20) train acc: 0.200000; val_acc: 0.144000\n",
      "(Epoch 2 / 20) train acc: 0.480000; val_acc: 0.146000\n",
      "(Epoch 3 / 20) train acc: 0.580000; val_acc: 0.128000\n",
      "(Epoch 4 / 20) train acc: 0.700000; val_acc: 0.163000\n",
      "(Epoch 5 / 20) train acc: 0.760000; val_acc: 0.145000\n",
      "(Iteration 11 / 40) loss: 19.422308\n",
      "(Epoch 6 / 20) train acc: 0.920000; val_acc: 0.149000\n",
      "(Epoch 7 / 20) train acc: 0.900000; val_acc: 0.156000\n",
      "(Epoch 8 / 20) train acc: 0.940000; val_acc: 0.150000\n",
      "(Epoch 9 / 20) train acc: 0.960000; val_acc: 0.154000\n",
      "(Epoch 10 / 20) train acc: 0.980000; val_acc: 0.154000\n",
      "(Iteration 21 / 40) loss: 0.615714\n",
      "(Epoch 11 / 20) train acc: 1.000000; val_acc: 0.151000\n",
      "(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.151000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.151000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.151000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.151000\n",
      "(Iteration 31 / 40) loss: 0.000000\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.151000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.151000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.151000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.151000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.151000\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmcAAAHwCAYAAADjOch3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3X2UnVd9H/rvL7JCprxEgBUXyQYT4oiXkFhEoVAIJZAgoGkQ3K4AKcFN6TW5hZY0VMTiJrc0N1zcqEBeVsKKAxSn4XUFIdyGVCGGlMANL7JlEAaUOGCKR8Z2SoQhzAVZ7PvHecaMFc1oNJ4zZ2vO57PWrHPOPs8+5zfbzxp/9exnP0+11gIAQB++bdIFAADwLcIZAEBHhDMAgI4IZwAAHRHOAAA6IpwBAHREOAPWVFVtqKqvVtUDV3PbFdTxK1X1ptX+3EW+60er6sYl3n99Vb18LWoB+nfOpAsA+lZVX13w8u8l+XqSE8PrF7bW3nwmn9daO5HkXqu97dmstfYvl7NdVd2U5HmttT8db0XAJAlnwJJaa3eGo+Hoz79srf3JYttX1TmttTvWojaWz38XOHuY1gTulmF68O1V9daq+kqS51XVY6vqw1V1rKpurqrfqKqNw/bnVFWrqguH178/vP9HVfWVqvrzqnrwmW47vP+0qvqLqvpyVf1mVX2oqv75Mn+PZ1bV9UPN76uqbQvee3lVHa2q26vqM1X1xKH9MVV17dB+S1XtPc13vKyqbhs+6/kL2n+/ql4xPP+uqnrPUMeXquoDQ/tbk2xJ8kfDVO/PL6Pum6pqd1UdTvK3VbWnqt5+Uk2/XVWvXs4YAWtDOANWwzOTvCXJdyZ5e5I7krwkyblJHpfkqUleuET/n0ryS0nul+R/Jvm/z3TbqvquJO9Isnv43s8lefRyiq+qhyX5L0n+dZLNSf4kyVVVtbGqHjHU/qjW2n2SPG343iT5zSR7h/bvSfIHS3zN+UlmMgpYP5vkdVV1n1NstzvJZ4c6/n6SX0yS1tpzkxxN8rTW2r1aa69Zqu4Fn/ecoeZNw7b/eP57q+rbkzw7ye8tZ5yAtSGcAavhg621/9pa+2Zrba619rHW2kdaa3e01j6b5Iok/2iJ/n/QWjvYWjue5M1JLl7Btj+e5LrW2ruH916b5K+XWf9zklzVWnvf0PfyjILmP8goaH5HkkcMU4OfG36nJDme5KKqun9r7SuttY8s8R3/X5Jfaa0db61dldG5e997iu2OZxTgHtha+0Zr7QMrrHver7fWbhr+u9yU5M+T/G/De09PMtta+/gS3wGsMeEMWA1fWPiiqh5aVX9YVV+sqtuT/HJGR7MW88UFz7+WpRcBLLbtloV1tNZakpuWUft8388v6PvNoe/W1tqRJC/N6He4dZi+/fvDpj+T5OFJjlTVR6vq6Ut8x18PCxxOVftClw+1XF1Vf1VVu1dS94JtvnBSnyuTPG94/ryMjqYBHRHOgNXQTnr9O0k+meR7him//ytJjbmGmzOaOkySVFXlriFlKUeTPGhB328bPms2SVprv99ae1ySByfZkORVQ/uR1tpzknxXklcneWdVfcfd+SVaa7e31v5ta+3CJLuS/EJVzR91PHmcl6x7kT77kvzgMF37tIyOPgIdEc6Acbh3ki9ndBL6w7L0+War5b8leVRV/ZOqOiejc942L7PvO5L8RFU9cThfa3eSryT5SFU9rKp+pKrukWRu+PlmklTVT1fVucMRqy9nFIS+eXd+iaH+hwzh8ssZXbZk/jNvSfLdy6l7sc9vrX0tybuSvDXJh1prR+9OvcDqE86AcXhpkksyCgq/k9EigbFqrd2S0cntr0nyv5I8JMmhjM7tOl3f6zOq93VJbstoAcNPDOdx3SPJr2Z0/toXk9w3yf85dH16kk8Pq1T/U5Jnt9a+cTd/lW1J3pfkq0k+lNE5Y382vPf/JPkPw8rMnztN3Uu5MskjY0oTulSj0zIA1peq2pDRtN8/XRBuSFJV353kE0nOa6397aTrAe7KkTNg3aiqp1bVpmEK8pcyWvn40QmX1ZXhvLSfT/IWwQz65A4BwHry+Iyut3ZOkuuTPLO1dtppzWlRVd+Z0WKBG5PsnGw1wGJMawIAdMS0JgBAR4QzAICOnNXnnJ177rntwgsvnHQZAACndc011/x1a+201188q8PZhRdemIMHD066DACA06qqz59+K9OaAABdEc4AADoinAEAdEQ4AwDoiHAGANAR4QwAoCPCGQBAR4QzAICOCGcAAB0RzgAAOiKcAQB0RDgDAOiIcAYA0BHhDACgI8IZAEBHzpl0AT3bf2g2ew8cydFjc9myaSa7d27Lru1bJ10WALCOCWeL2H9oNnv2Hc7c8RNJktljc9mz73CSCGgAwNiY1lzE3gNH7gxm8+aOn8jeA0cmVBEAMA2Es0UcPTZ3Ru0AAKtBOFvElk0zZ9QOALAahLNF7N65LTMbN9ylbWbjhuzeuW1CFQEA08CCgEXMn/RvtSYAsJaEsyXs2r5VGAMA1pRpTQCAjghnAAAdEc4AADoinAEAdEQ4AwDoiHAGANAR4QwAoCPCGQBAR4QzAICOCGcAAB0RzgAAOiKcAQB0RDgDAOiIcAYA0BHhDACgI8IZAEBHhDMAgI4IZwAAHRHOAAA6IpwBAHREOAMA6IhwBgDQEeEMAKAjwhkAQEeEMwCAjghnAAAdEc4AADoinAEAdEQ4AwDoyNjCWVVdUFXvr6pPVdX1VfWSof0VVTVbVdcNP09f0GdPVd1QVUeqaue4agMA6NU5Y/zsO5K8tLV2bVXdO8k1VfXe4b3Xttb+08KNq+rhSZ6T5BFJtiT5k6r63tbaiTHWCADQlbEdOWut3dxau3Z4/pUkn06ydYkuz0jyttba11trn0tyQ5JHj6s+AIAerck5Z1V1YZLtST4yNL24qj5RVW+sqvsObVuTfGFBt5uydJgDAFh3xh7OqupeSd6Z5Odaa7cneV2ShyS5OMnNSV59hp93aVUdrKqDt91226rXCwAwSWMNZ1W1MaNg9ubW2r4kaa3d0lo70Vr7ZpLfzbemLmeTXLCg+/lD21201q5ore1ore3YvHnzOMsHAFhz41ytWUnekOTTrbXXLGh/wILNnpnkk8Pzq5I8p6ruUVUPTnJRko+Oqz4AgB6Nc7Xm45L8dJLDVXXd0PbyJM+tqouTtCQ3JnlhkrTWrq+qdyT5VEYrPV9kpSYAMG3GFs5aax9MUqd46z1L9HllkleOqyYAgN65QwAAQEeEMwCAjghnAAAdEc4AADoinAEAdEQ4AwDoiHAGANAR4QwAoCPCGQBAR4QzAICOCGcAAB0RzgAAOiKcAQB0RDgDAOiIcAYA0BHhDACgI8IZAEBHhDMAgI4IZwAAHRHOAAA6IpwBAHREOAMA6IhwBgDQEeEMAKAjwhkAQEeEMwCAjghnAAAdEc4AADoinAEAdEQ4AwDoiHAGANAR4QwAoCPCGQBAR4QzAICOCGcAAB0RzgAAOiKcAQB0RDgDAOiIcAYA0BHhDACgI8IZAEBHhDMAgI4IZwAAHRHOAAA6IpwBAHREOAMA6IhwBgDQEeEMAKAjwhkAQEeEMwCAjghnAAAdEc4AADoinAEAdEQ4AwDoiHAGANAR4QwAoCPCGQBAR4QzAICOCGcAAB0RzgAAOiKcAQB0RDgDAOiIcAYA0JGxhbOquqCq3l9Vn6qq66vqJUP7/arqvVX1l8PjfYf2qqrfqKobquoTVfWocdUGANCrcR45uyPJS1trD0/ymCQvqqqHJ7ksydWttYuSXD28TpKnJblo+Lk0yevGWBsAQJfGFs5aaze31q4dnn8lyaeTbE3yjCRXDptdmWTX8PwZSX6vjXw4yaaqesC46gMA6NGanHNWVRcm2Z7kI0nOa63dPLz1xSTnDc+3JvnCgm43DW0nf9alVXWwqg7edtttY6sZAGASxh7OqupeSd6Z5Odaa7cvfK+11pK0M/m81toVrbUdrbUdmzdvXsVKAQAmb6zhrKo2ZhTM3txa2zc03zI/XTk83jq0zya5YEH384c2AICpMc7VmpXkDUk+3Vp7zYK3rkpyyfD8kiTvXtD+/GHV5mOSfHnB9CcAwFQ4Z4yf/bgkP53kcFVdN7S9PMnlSd5RVS9I8vkkPzm8954kT09yQ5KvJfmZMdYGANClsYWz1toHk9Qibz/5FNu3JC8aVz0AAGcDdwgAAOiIcAYA0BHhDACgI8IZAEBHhDMAgI4IZwAAHRHOAAA6IpwBAHREOAMA6IhwBgDQEeEMAKAjwhkAQEeEMwCAjghnAAAdEc4AADoinAEAdEQ4AwDoiHAGANAR4QwAoCPCGQBAR4QzAICOCGcAAB0RzgAAOiKcAQB0RDgDAOiIcAYA0BHhDACgI8IZAEBHhDMAgI4IZwAAHRHOAAA6cs6kC1hv9h+azd4DR3L02Fy2bJrJ7p3bsmv71kmXBQCcJYSzVbT/0Gz27DucueMnkiSzx+ayZ9/hJBHQAIBlMa25ivYeOHJnMJs3d/xE9h44MqGKAICzjXC2io4emzujdgCAkwlnq2jLppkzagcAOJlwtop279yWmY0b7tI2s3FDdu/cNqGKAICzjQUBq2j+pH+rNQGAlRLOVtmu7VuFMQBgxUxrAgB0RDgDAOiIcAYA0BHhDACgI8IZAEBHhDMAgI4IZwAAHRHOAAA6IpwBAHREOAMA6IhwBgDQEeEMAKAjZxTOauSe4yoGAGDanTacVdXvVdV9qurvJTmc5Iaq+vnxlwYAMH2Wc+Ts+1trtyfZleS9SR6U5J+PsygAgGm1nHC2sarOSfKMJO9urX0jyTfHWxYAwHRaTjh7fZL/meS+Sf5HVT0wyVfHWhUAwJQ6bThrrb22tbaltfaU1lpL8oUkTxp/aQAA02c5CwJeXFX3GZ7/TpKPJPnhcRcGADCNljOteWlr7faqekqS85L870l+dbxlAQBMp+WEszY8Pj3Jf2mtfXyZ/QAAOEPLCVkfr6r3JPnxJH9UVffKtwIbAACr6JxlbPMzSX4wyQ2tta9V1blJXjDesgAAptNyVmueSHJukpdV1eVJfqi1duh0/arqjVV1a1V9ckHbK6pqtqquG36evuC9PVV1Q1UdqaqdK/x9AADOastZrfnKJC9L8tnhZ3dV/coyPvtNSZ56ivbXttYuHn7eM3zHw5M8J8kjhj6/XVUblvcrAACsH8uZ1vwnSR7VWrsjGR0RS3Jtkl9cqlNr7QNVdeEy63hGkre11r6e5HNVdUOSRyf582X2BwBYF5a76vLeizxfiRdX1SeGac/7Dm1bM7q47bybhjYAgKmynHD2q0murarXV9UbkhxMcvkKv+91SR6S5OIkNyd59Zl+QFVdWlUHq+rgbbfdtsIyAAD6tJwFAb+f5PFJ3pPkD5M8obX2lpV8WWvtltbaidbaN5P8bkZTl0kym+SCBZueP7Sd6jOuaK3taK3t2Lx580rKAADo1qLnnFXV95/UdMPweP+qun9r7RNn+mVV9YDW2s3Dy2cmmV/JeVWSt1TVa5JsSXJRko+e6ecDAJztlloQ8FtLvNeSPGGpD66qtyZ5YpJzq+qmJP8+yROr6uKh/41JXpgkrbXrq+odST6V5I4kLxou4QEAMFWqtbP3Yv87duxoBw8enHQZAACnVVXXtNZ2nG4798gEAOiIcAYA0BHhDACgI6e9Q8ApVm0myZeTfGG4JAYAAKtkObdvekNGF429PkkleVhGqyrvXVWXttauHmN9AABTZTnTmjcm+cHhRuU/kOQHk/xFkp1ZwRX+AQBY3HLC2cMWXnC2tXY4ycNbazcs0QcAgBVYzrTmZ6rqN5O8bXj97KHtHhldMBYAgFWynCNnz09yU5LLhp+jSS7JKJg9eXylAQBMn9MeOWutfS3Jfxx+TvblVa8IAGCKLedSGo/J6L6YD1q4fWvte8dYFwDAVFrOOWf/OcnLklyTxM3IAQDGaDnh7PbW2n8deyUAACwrnL2vql6VZF+Sr883Lry8BgAAq2M54ezxJz0mSUvyhNUvBwBgui1nteYPr0UhAAAsEc6q6rmttbdW1b851futtd8YX1kAANNpqSNn9x0eN69FIQAALBHOWmu/PTz+0tqVAwAw3ZZzEdpzk/yLJBfmrhehvXR8ZQEATKflrNZ8d5IPJ/lgXIQWAGCslhPO7tlae+nYKwEAIN+2jG3+qKqeMvZKAABY1pGzn03yC1X1tSTfSFJJWmvtfmOtbIrsPzSbvQeO5OixuWzZNJPdO7dl1/atky4LAJiA5YSzc8dexRTbf2g2e/Ydztzx0el8s8fmsmff4SQR0ABgCi06rVlVFw1PH7HID6tg74EjdwazeXPHT2TvgSMTqggAmKSljpxdluQFSX7rFO+5t+YqOXps7ozaAYD1bamL0L5geHRvzTHasmkms6cIYls2zUygGgBg0pazWjNV9dCqelZV/dT8z7gLmxa7d27LzMYNd2mb2bghu3dum1BFAMAkLecOAb+Y5ClJHprkQJKdGV2Q9i3jLW06zJ/0b7UmAJAsb7Xms5NcnOTa1tpPV9UDkrxprFVNmV3btwpjAECS5U1rzrXWTiS5o6runeSLSR403rIAAKbTco6cHaqqTUnemORgktuTfHSsVQEATKklw1lVVZJXtNaOJfmtqjqQ5D6ttWvXpDoAgCmzZDhrrbWqem+S7xte37AmVQEATKnlnHN2XVVtH3slAAAsfuSsqs5prd2RZHuSj1XVXyX523zrxuePWqMaAQCmxlLTmh9N8qgkP7FGtXAG9h+adW00AFiHlgpnlSSttb9ao1pYpv2HZrNn3+E7b5g+e2wue/YdThIBDQDOckuFs81V9fOLvdlae80Y6mEZ9h44cmcwmzd3/ET2HjginAHAWW6pcLYhyb0yHEGjH0dPcaP0pdoBgLPHUuHs5tbaL69ZJSzblk0zmT1FENuyaWYC1QAAq2mpS2k4Ytap3Tu3ZWbjhru0zWzckN07t02oIgBgtSx15OzJa1YFZ2T+vDKrNQFg/Vk0nLXWvrSWhXBmdm3fKowBwDq0nDsEAACwRoQzAICOCGcAAB0RzgAAOiKcAQB0RDgDAOiIcAYA0BHhDACgI8IZAEBHhDMAgI4IZwAAHRHOAAA6IpwBAHTknEkXAEmy/9Bs9h44kqPH5rJl00x279yWXdu3TrosAFhzwhkTt//QbPbsO5y54yeSJLPH5rJn3+EkEdAAmDqmNZm4vQeO3BnM5s0dP5G9B45MqCIAmBzhjIk7emzujNoBYD0bWzirqjdW1a1V9ckFbferqvdW1V8Oj/cd2quqfqOqbqiqT1TVo8ZVF/3ZsmnmjNoBYD0b55GzNyV56kltlyW5urV2UZKrh9dJ8rQkFw0/lyZ53RjrojO7d27LzMYNd2mb2bghu3dum1BFADA5YwtnrbUPJPnSSc3PSHLl8PzKJLsWtP9eG/lwkk1V9YBx1UZfdm3fmlc965HZumkmlWTrppm86lmPtBgAgKm01qs1z2ut3Tw8/2KS84bnW5N8YcF2Nw1tN4epsGv7VmEMADLBBQGttZaknWm/qrq0qg5W1cHbbrttDJUBAEzOWh85u6WqHtBau3mYtrx1aJ9NcsGC7c4f2v6O1toVSa5Ikh07dpxxuJtmLvQKAP1b6yNnVyW5ZHh+SZJ3L2h//rBq8zFJvrxg+pNVMH+h19ljc2n51oVe9x86ZQYGACZknJfSeGuSP0+yrapuqqoXJLk8yY9V1V8m+dHhdZK8J8lnk9yQ5HeT/Ktx1TWtXOgVAM4OY5vWbK09d5G3nnyKbVuSF42rFlzoFQDOFu4QMCVc6BUAzg7C2ZRwoVcAODus9WpNJmR+VabVmgDQN+FsirjQKwD0z7QmAEBHhDMAgI4IZwAAHRHOAAA6IpwBAHREOAMA6IhwBgDQEeEMAKAjwhkAQEeEMwCAjghnAAAdEc4AADoinAEAdEQ4AwDoiHAGANAR4QwAoCPCGQBAR4QzAICOCGcAAB0RzgAAOiKcAQB0RDgDAOiIcAYA0BHhDACgI8IZAEBHhDMAgI4IZwAAHRHOAAA6cs6kC2D92X9oNnsPHMnRY3PZsmkmu3duy67tWyddFgCcFYQzVtX+Q7PZs+9w5o6fSJLMHpvLnn2Hk0RAA4BlMK3Jqtp74MidwWze3PET2XvgyIQqAoCzi3DGqjp6bO6M2gGAuxLOWFVbNs2cUTsAcFfCGatq985tmdm44S5tMxs3ZPfObROqCADOLhYEsKrmT/q3WhMAVkY4Y9Xt2r5VGAOAFTKtCQDQEeEMAKAjwhkAQEeEMwCAjghnAAAdEc4AADoinAEAdEQ4AwDoiHAGANARdwhgSfsPzboVEwCsIeGMRe0/NJs9+w5n7viJJMnssbns2Xc4SQQ0ABgT05osau+BI3cGs3lzx09k74EjE6oIANY/4YxFHT02d0btAMDdJ5yxqC2bZs6oHQC4+4QzFrV757bMbNxwl7aZjRuye+e2CVUEAOufBQEsav6kf6s1AWDtCGcsadf2rcIYAKwh05oAAB0RzgAAOiKcAQB0RDgDAOiIcAYA0BHhDACgIxO5lEZV3ZjkK0lOJLmjtbajqu6X5O1JLkxyY5KfbK39zSTqAwCYlEkeOfuR1trFrbUdw+vLklzdWrsoydXDawCAqdLTtOYzklw5PL8yya4J1gIAMBGTCmctyR9X1TVVdenQdl5r7ebh+ReTnDeZ0gAAJmdSt296fGtttqq+K8l7q+ozC99srbWqaqfqOIS5S5PkgQ984PgrBQBYQxM5ctZamx0eb03yriSPTnJLVT0gSYbHWxfpe0VrbUdrbcfmzZvXqmQAgDWx5uGsqu5ZVfeef57kKUk+meSqJJcMm12S5N1rXRsAwKRNYlrzvCTvqqr5739La+2/V9XHkryjql6Q5PNJfnICtQEATNSah7PW2meT/MAp2v9XkievdT0AAD3p6VIaAABTTzgDAOiIcAYA0BHhDACgI8IZAEBHhDMAgI4IZwAAHRHOAAA6IpwBAHREOAMA6IhwBgDQEeEMAKAjwhkAQEeEMwCAjghnAAAdEc4AADoinAEAdEQ4AwDoiHAGANAR4QwAoCPCGQBAR86ZdAGwlvYfms3eA0dy9Nhctmyaye6d27Jr+9ZJlwUAdxLOmBr7D81mz77DmTt+Ikkye2wue/YdThIBDYBumNZkauw9cOTOYDZv7viJ7D1wZEIVAcDfJZwxNY4emzujdgCYBOGMqbFl08wZtQPAJAhnTI3dO7dlZuOGu7TNbNyQ3Tu3TagiAPi7LAhgasyf9G+1JgA9E86YKru2bxXGAOiaaU0AgI4IZwAAHRHOAAA6IpwBAHREOAMA6IhwBgDQEZfSgNPYf2jWtdEAWDPCGSxh/6HZ7Nl3+M4bps8em8uefYeTREADYCxMa8IS9h44cmcwmzd3/ET2HjgyoYoAWO+EM1jC0WNzZ9QOAHeXcAZL2LJp5ozaAeDuEs5gCbt3bsvMxg13aZvZuCG7d26bUEUArHcWBMAS5k/6t1oTgLUinMFp7Nq+VRgDYM2Y1gQA6IhwBgDQEeEMAKAjwhkAQEeEMwCAjlityVnLDcmNAcB6JJxxVnJDcmMAsF6Z1uSs5IbkxgBgvXLkjLNS7zckX4vpxt7HAICVceSMs1LPNySfn26cPTaXlm9NN+4/NLuq39PzGACwcsIZZ6Web0i+VtONPY8BACtnWpOzUs83JF+r6caexwCAlRPOOGv1ekPyLZtmMnuKIDaO6cZexwCAlTOtCaus9+nG/Ydm87jL35cHX/aHedzl71v1c+EAuHscOYNV1vN0o2ujAfRPOIMx6HW6canFCj3WCzCNTGvCFHFtNID+CWcwRVwbDaB/whlMkd4XKwDQ4TlnVfXUJL+eZEOS17fWLp9wSbAm1uKWTytdrLAWtfXOGABrpVprk67hTlW1IclfJPmxJDcl+ViS57bWPnWq7Xfs2NEOHjy4hhXCeJy8ijIZHdF61bMeOfEAsNLaVhJmeu1jDPTRR5/VUFXXtNZ2nHa7zsLZY5O8orW2c3i9J0laa6861fbCGevF4y5/3ykvXLt100w+dNmTJlDRt6yktpWEmZ77GAN99NFnNSw3nPV2ztnWJF9Y8PqmoQ3WtZ5XUa6ktpXcX7TnPsZAH330WUu9hbPTqqpLq+pgVR287bbbJl0OrIqeV1GupLaVhJme+xgDffTRZy31Fs5mk1yw4PX5Q9udWmtXtNZ2tNZ2bN68eU2Lg3HpeRXlSmpbSZjpuY8x0EcffdZSb+HsY0kuqqoHV9W3J3lOkqsmXBOM3a7tW/OqZz0yWzfNpDI6l6mHxQArrW0lYabnPsZAH330WUtdLQhIkqp6epJfy+hSGm9srb1ysW0tCIB+9bzSaq1WZ/X8++ijjz4r77NSZ+VqzTMlnAEAZ4uzdbUmAMBUE84AADoinAEAdEQ4AwDoiHAGANAR4QwAoCPCGQBAR4QzAICOCGcAAB0RzgAAOiKcAQB0RDgDAOiIcAYA0BHhDACgI8IZAEBHqrU26RpWrKpuS/L5Nfiqc5P89Rp8T8+MgTFIjEFiDBJjkBiDxBgkZz4GD2qtbT7dRmd1OFsrVXWwtbZj0nVMkjEwBokxSIxBYgwSY5AYg2R8Y2BaEwCgI8IZAEBHhLPluWLSBXTAGBiDxBgkxiAxBokxSIxBMqYxcM4ZAEBHHDkDAOiIcLaEqnpqVR2pqhuq6rJJ1zMJVXVjVR2uquuq6uCk61kLVfXGqrq1qj65oO1+VfXeqvrL4fG+k6xx3BYZg1dU1eywL1xXVU+fZI3jVlUXVNX7q+pTVXV9Vb1kaJ+afWGJMZiafaGqvqOqPlpVHx/G4D8M7Q+uqo8M/394e1V9+6RrHZclxuBNVfW5BfvBxZOuddyqakNVHaqq/za8Hst+IJwtoqo2JPmtJE9L8vAkz62qh0+2qon5kdbaxVO0ZPpNSZ56UttlSa5urV2U5Orh9Xr2pvzdMUiS1w77wsWttfescU1r7Y4kL22tPTzJY5K8aPgbME37wmJjkEzPvvD1JE9qrf1AkouTPLWqHpPkP2Y0Bt+T5G+SvGCCNY7bYmOQJLsX7AfXTa7ENfOPnHYvAAAFaElEQVSSJJ9e8Hos+4FwtrhHJ7mhtfbZ1to3krwtyTMmXBNroLX2gSRfOqn5GUmuHJ5fmWTXmha1xhYZg6nSWru5tXbt8PwrGf1B3pop2heWGIOp0Ua+OrzcOPy0JE9K8gdD+3rfDxYbg6lSVecn+cdJXj+8roxpPxDOFrc1yRcWvL4pU/ZHadCS/HFVXVNVl066mAk6r7V28/D8i0nOm2QxE/TiqvrEMO25bqfzTlZVFybZnuQjmdJ94aQxSKZoXximsq5LcmuS9yb5qyTHWmt3DJus+/8/nDwGrbX5/eCVw37w2qq6xwRLXAu/luRlSb45vL5/xrQfCGeczuNba4/KaHr3RVX1hEkXNGlttMR56v7VmOR1SR6S0bTGzUlePdly1kZV3SvJO5P8XGvt9oXvTcu+cIoxmKp9obV2orV2cZLzM5pVeeiES1pzJ49BVX1fkj0ZjcUPJblfkl+YYIljVVU/nuTW1to1a/F9wtniZpNcsOD1+UPbVGmtzQ6PtyZ5V0Z/mKbRLVX1gCQZHm+dcD1rrrV2y/AH+ptJfjdTsC9U1caMQsmbW2v7huap2hdONQbTuC8kSWvtWJL3J3lskk1Vdc7w1tT8/2HBGDx1mPZurbWvJ/nPWd/7weOS/ERV3ZjRaU5PSvLrGdN+IJwt7mNJLhpWYnx7kuckuWrCNa2pqrpnVd17/nmSpyT55NK91q2rklwyPL8kybsnWMtEzAeSwTOzzveF4XySNyT5dGvtNQvempp9YbExmKZ9oao2V9Wm4flMkh/L6Ny79yf5p8Nm630/ONUYfGbBP1Iqo3Ot1u1+0Frb01o7v7V2YUZ54H2ttX+WMe0HLkK7hGF5+K8l2ZDkja21V064pDVVVd+d0dGyJDknyVumYQyq6q1Jnpjk3CS3JPn3SfYneUeSByb5fJKfbK2t2xPmFxmDJ2Y0jdWS3JjkhQvOvVp3qurxSf4syeF86xyTl2d0ztVU7AtLjMFzMyX7QlV9f0Ynem/I6IDGO1prvzz8fXxbRtN5h5I8bziCtO4sMQbvS7I5SSW5LsnPLlg4sG5V1ROT/LvW2o+Paz8QzgAAOmJaEwCgI8IZAEBHhDMAgI4IZwAAHRHOAAA6IpwBZ72q+urweGFV/dQqf/bLT3r9/67m5wOcTDgD1pMLk5xROFtwde/F3CWctdb+4RnWBHBGhDNgPbk8yQ9X1XVV9W+HmzXvraqPDTdnfmEyuohkVf1ZVV2V5FND2/6quqaqrq+qS4e2y5PMDJ/35qFt/ihdDZ/9yao6XFXPXvDZf1pVf1BVn6mqNw9XUAdYltP9ixHgbHJZhit3J8kQsr7cWvuhqrpHkg9V1R8P2z4qyfe11j43vP4XrbUvDben+VhVvbO1dllVvXi44fPJnpXRVfJ/IKM7KXysqj4wvLc9ySOSHE3yoYzuy/fB1f91gfXIkTNgPXtKkudX1XUZ3Xbp/kkuGt776IJgliT/pqo+nuTDSS5YsN1iHp/krcMNwG9J8j+S/NCCz75puDH4dRlNtwIsiyNnwHpWSf51a+3AXRpH98b725Ne/2iSx7bWvlZVf5rkO+7G9y68t96J+FsLnAFHzoD15CtJ7r3g9YEk/0dVbUySqvreqrrnKfp9Z5K/GYLZQ5M8ZsF7x+f7n+TPkjx7OK9tc5InJPnoqvwWwFTzrzlgPflEkhPD9OSbkvx6RlOK1w4n5d+WZNcp+v33JD9bVZ9OciSjqc15VyT5RFVd21r7Zwva35XksUk+nqQleVlr7YtDuANYsWqtTboGAAAGpjUBADoinAEAdEQ4AwDoiHAGANAR4QwAoCPCGQBAR4QzAICOCGcAAB35/wF/mVbYqaAupAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a three-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 1e-1   # Experiment with this!\n",
    "learning_rate = 5e-4  # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100],\n",
    "              weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again, you will have to adjust the learning rate and weight initialization scale, but you should be able to achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 3563.416959\n",
      "(Epoch 0 / 20) train acc: 0.200000; val_acc: 0.095000\n",
      "(Epoch 1 / 20) train acc: 0.200000; val_acc: 0.091000\n",
      "(Epoch 2 / 20) train acc: 0.280000; val_acc: 0.114000\n",
      "(Epoch 3 / 20) train acc: 0.500000; val_acc: 0.120000\n",
      "(Epoch 4 / 20) train acc: 0.460000; val_acc: 0.102000\n",
      "(Epoch 5 / 20) train acc: 0.460000; val_acc: 0.123000\n",
      "(Iteration 11 / 40) loss: 519.123909\n",
      "(Epoch 6 / 20) train acc: 0.640000; val_acc: 0.106000\n",
      "(Epoch 7 / 20) train acc: 0.740000; val_acc: 0.107000\n",
      "(Epoch 8 / 20) train acc: 0.780000; val_acc: 0.098000\n",
      "(Epoch 9 / 20) train acc: 0.840000; val_acc: 0.103000\n",
      "(Epoch 10 / 20) train acc: 0.880000; val_acc: 0.114000\n",
      "(Iteration 21 / 40) loss: 14.915832\n",
      "(Epoch 11 / 20) train acc: 0.880000; val_acc: 0.106000\n",
      "(Epoch 12 / 20) train acc: 0.860000; val_acc: 0.113000\n",
      "(Epoch 13 / 20) train acc: 0.980000; val_acc: 0.121000\n",
      "(Epoch 14 / 20) train acc: 0.980000; val_acc: 0.121000\n",
      "(Epoch 15 / 20) train acc: 0.960000; val_acc: 0.118000\n",
      "(Iteration 31 / 40) loss: 0.900287\n",
      "(Epoch 16 / 20) train acc: 0.960000; val_acc: 0.110000\n",
      "(Epoch 17 / 20) train acc: 0.960000; val_acc: 0.110000\n",
      "(Epoch 18 / 20) train acc: 0.960000; val_acc: 0.110000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.109000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.109000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a five-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "learning_rate = 2e-5  # Experiment with this!\n",
    "weight_scale = 2e-1   # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100, 100, 100],\n",
    "                weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 2: \n",
    "Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net? In particular, based on your experience, which network seemed more sensitive to the initialization scale? Why do you think that is the case?\n",
    "\n",
    "## Answer:\n",
    "更深的网络更敏感啊，更容易梯度爆炸或者消失\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Update rules\n",
    "So far we have used vanilla stochastic gradient descent (SGD) as our update rule. More sophisticated update rules can make it easier to train deep networks. We will implement a few of the most commonly used update rules and compare them to vanilla SGD."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SGD+Momentum\n",
    "Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochastic gradient descent. See the Momentum Update section at http://cs231n.github.io/neural-networks-3/#sgd for more information.\n",
    "\n",
    "Open the file `cs231n/optim.py` and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. You should see errors less than e-8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  8.882347033505819e-09\n",
      "velocity error:  4.269287743278663e-09\n"
     ]
    }
   ],
   "source": [
    "from cs231n.optim import sgd_momentum\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-3, 'velocity': v}\n",
    "next_w, _ = sgd_momentum(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [ 0.1406,      0.20738947,  0.27417895,  0.34096842,  0.40775789],\n",
    "  [ 0.47454737,  0.54133684,  0.60812632,  0.67491579,  0.74170526],\n",
    "  [ 0.80849474,  0.87528421,  0.94207368,  1.00886316,  1.07565263],\n",
    "  [ 1.14244211,  1.20923158,  1.27602105,  1.34281053,  1.4096    ]])\n",
    "expected_velocity = np.asarray([\n",
    "  [ 0.5406,      0.55475789,  0.56891579, 0.58307368,  0.59723158],\n",
    "  [ 0.61138947,  0.62554737,  0.63970526,  0.65386316,  0.66802105],\n",
    "  [ 0.68217895,  0.69633684,  0.71049474,  0.72465263,  0.73881053],\n",
    "  [ 0.75296842,  0.76712632,  0.78128421,  0.79544211,  0.8096    ]])\n",
    "\n",
    "# Should see relative errors around e-8 or less\n",
    "print('next_w error: ', rel_error(next_w, expected_next_w))\n",
    "print('velocity error: ', rel_error(expected_velocity, config['velocity']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  sgd\n",
      "(Iteration 1 / 200) loss: 2.531059\n",
      "(Epoch 0 / 5) train acc: 0.099000; val_acc: 0.093000\n",
      "(Iteration 11 / 200) loss: 2.342757\n",
      "(Iteration 21 / 200) loss: 2.179883\n",
      "(Iteration 31 / 200) loss: 2.289512\n",
      "(Epoch 1 / 5) train acc: 0.214000; val_acc: 0.183000\n",
      "(Iteration 41 / 200) loss: 2.147662\n",
      "(Iteration 51 / 200) loss: 2.102569\n",
      "(Iteration 61 / 200) loss: 1.996101\n",
      "(Iteration 71 / 200) loss: 2.119799\n",
      "(Epoch 2 / 5) train acc: 0.283000; val_acc: 0.241000\n",
      "(Iteration 81 / 200) loss: 2.003925\n",
      "(Iteration 91 / 200) loss: 2.103034\n",
      "(Iteration 101 / 200) loss: 2.014964\n",
      "(Iteration 111 / 200) loss: 1.995835\n",
      "(Epoch 3 / 5) train acc: 0.335000; val_acc: 0.274000\n",
      "(Iteration 121 / 200) loss: 1.937863\n",
      "(Iteration 131 / 200) loss: 1.895321\n",
      "(Iteration 141 / 200) loss: 1.876990\n",
      "(Iteration 151 / 200) loss: 2.019296\n",
      "(Epoch 4 / 5) train acc: 0.356000; val_acc: 0.276000\n",
      "(Iteration 161 / 200) loss: 1.811299\n",
      "(Iteration 171 / 200) loss: 1.866178\n",
      "(Iteration 181 / 200) loss: 1.764085\n",
      "(Iteration 191 / 200) loss: 1.765903\n",
      "(Epoch 5 / 5) train acc: 0.357000; val_acc: 0.299000\n",
      "\n",
      "running with  sgd_momentum\n",
      "(Iteration 1 / 200) loss: 2.702576\n",
      "(Epoch 0 / 5) train acc: 0.087000; val_acc: 0.104000\n",
      "(Iteration 11 / 200) loss: 2.179898\n",
      "(Iteration 21 / 200) loss: 2.063103\n",
      "(Iteration 31 / 200) loss: 1.955446\n",
      "(Epoch 1 / 5) train acc: 0.295000; val_acc: 0.291000\n",
      "(Iteration 41 / 200) loss: 1.830529\n",
      "(Iteration 51 / 200) loss: 1.918751\n",
      "(Iteration 61 / 200) loss: 1.760611\n",
      "(Iteration 71 / 200) loss: 1.774274\n",
      "(Epoch 2 / 5) train acc: 0.394000; val_acc: 0.313000\n",
      "(Iteration 81 / 200) loss: 1.804290\n",
      "(Iteration 91 / 200) loss: 1.623133\n",
      "(Iteration 101 / 200) loss: 1.544048\n",
      "(Iteration 111 / 200) loss: 1.572209\n",
      "(Epoch 3 / 5) train acc: 0.461000; val_acc: 0.340000\n",
      "(Iteration 121 / 200) loss: 1.718809\n",
      "(Iteration 131 / 200) loss: 1.410283\n",
      "(Iteration 141 / 200) loss: 1.577564\n",
      "(Iteration 151 / 200) loss: 1.536882\n",
      "(Epoch 4 / 5) train acc: 0.459000; val_acc: 0.356000\n",
      "(Iteration 161 / 200) loss: 1.521448\n",
      "(Iteration 171 / 200) loss: 1.163303\n",
      "(Iteration 181 / 200) loss: 1.467059\n",
      "(Iteration 191 / 200) loss: 1.580117\n",
      "(Epoch 5 / 5) train acc: 0.538000; val_acc: 0.373000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/cww97/anaconda3/envs/cs231n/lib/python3.7/site-packages/matplotlib/figure.py:98: MatplotlibDeprecationWarning: \n",
      "Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  \"Adding an axes using the same arguments as a previous axes \"\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_train = 4000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "solvers = {}\n",
    "\n",
    "for update_rule in ['sgd', 'sgd_momentum']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': 5e-3,\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in solvers.items():\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=\"loss_%s\" % update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=\"train_acc_%s\" % update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=\"val_acc_%s\" % update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RMSProp and Adam\n",
    "RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.\n",
    "\n",
    "In the file `cs231n/optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.\n",
    "\n",
    "**NOTE:** Please implement the _complete_ Adam update rule (with the bias correction mechanism), not the first simplified version mentioned in the course notes. \n",
    "\n",
    "[1] Tijmen Tieleman and Geoffrey Hinton. \"Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.\" COURSERA: Neural Networks for Machine Learning 4 (2012).\n",
    "\n",
    "[2] Diederik Kingma and Jimmy Ba, \"Adam: A Method for Stochastic Optimization\", ICLR 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  9.524687511038133e-08\n",
      "cache error:  2.6477955807156126e-09\n"
     ]
    }
   ],
   "source": [
    "# Test RMSProp implementation\n",
    "from cs231n.optim import rmsprop\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'cache': cache}\n",
    "next_w, _ = rmsprop(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],\n",
    "  [-0.132737,   -0.08078555, -0.02881884,  0.02316247,  0.07515774],\n",
    "  [ 0.12716641,  0.17918792,  0.23122175,  0.28326742,  0.33532447],\n",
    "  [ 0.38739248,  0.43947102,  0.49155973,  0.54365823,  0.59576619]])\n",
    "expected_cache = np.asarray([\n",
    "  [ 0.5976,      0.6126277,   0.6277108,   0.64284931,  0.65804321],\n",
    "  [ 0.67329252,  0.68859723,  0.70395734,  0.71937285,  0.73484377],\n",
    "  [ 0.75037008,  0.7659518,   0.78158892,  0.79728144,  0.81302936],\n",
    "  [ 0.82883269,  0.84469141,  0.86060554,  0.87657507,  0.8926    ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('cache error: ', rel_error(expected_cache, config['cache']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  0.20720703668629928\n",
      "v error:  4.208314038113071e-09\n",
      "m error:  4.214963193114416e-09\n"
     ]
    }
   ],
   "source": [
    "# Test Adam implementation\n",
    "from cs231n.optim import adam\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}\n",
    "next_w, _ = adam(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],\n",
    "  [-0.1380274,  -0.08544591, -0.03286534,  0.01971428,  0.0722929],\n",
    "  [ 0.1248705,   0.17744702,  0.23002243,  0.28259667,  0.33516969],\n",
    "  [ 0.38774145,  0.44031188,  0.49288093,  0.54544852,  0.59801459]])\n",
    "expected_v = np.asarray([\n",
    "  [ 0.69966,     0.68908382,  0.67851319,  0.66794809,  0.65738853,],\n",
    "  [ 0.64683452,  0.63628604,  0.6257431,   0.61520571,  0.60467385,],\n",
    "  [ 0.59414753,  0.58362676,  0.57311152,  0.56260183,  0.55209767,],\n",
    "  [ 0.54159906,  0.53110598,  0.52061845,  0.51013645,  0.49966,   ]])\n",
    "expected_m = np.asarray([\n",
    "  [ 0.48,        0.49947368,  0.51894737,  0.53842105,  0.55789474],\n",
    "  [ 0.57736842,  0.59684211,  0.61631579,  0.63578947,  0.65526316],\n",
    "  [ 0.67473684,  0.69421053,  0.71368421,  0.73315789,  0.75263158],\n",
    "  [ 0.77210526,  0.79157895,  0.81105263,  0.83052632,  0.85      ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('v error: ', rel_error(expected_v, config['v']))\n",
    "print('m error: ', rel_error(expected_m, config['m']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  adam\n",
      "(Iteration 1 / 200) loss: 2.869932\n",
      "(Epoch 0 / 5) train acc: 0.141000; val_acc: 0.117000\n",
      "(Iteration 11 / 200) loss: 2.375284\n",
      "(Iteration 21 / 200) loss: 2.088855\n",
      "(Iteration 31 / 200) loss: 2.034846\n",
      "(Epoch 1 / 5) train acc: 0.288000; val_acc: 0.262000\n",
      "(Iteration 41 / 200) loss: 2.001631\n",
      "(Iteration 51 / 200) loss: 2.060530\n",
      "(Iteration 61 / 200) loss: 1.845564\n",
      "(Iteration 71 / 200) loss: 1.876653\n",
      "(Epoch 2 / 5) train acc: 0.294000; val_acc: 0.250000\n",
      "(Iteration 81 / 200) loss: 1.884512\n",
      "(Iteration 91 / 200) loss: 1.824110\n",
      "(Iteration 101 / 200) loss: 1.818473\n",
      "(Iteration 111 / 200) loss: 1.620882\n",
      "(Epoch 3 / 5) train acc: 0.365000; val_acc: 0.328000\n",
      "(Iteration 121 / 200) loss: 1.694918\n",
      "(Iteration 131 / 200) loss: 1.785445\n",
      "(Iteration 141 / 200) loss: 1.671010\n",
      "(Iteration 151 / 200) loss: 1.714908\n",
      "(Epoch 4 / 5) train acc: 0.366000; val_acc: 0.323000\n",
      "(Iteration 161 / 200) loss: 1.801044\n",
      "(Iteration 171 / 200) loss: 1.631624\n",
      "(Iteration 181 / 200) loss: 1.767741\n",
      "(Iteration 191 / 200) loss: 1.550835\n",
      "(Epoch 5 / 5) train acc: 0.446000; val_acc: 0.367000\n",
      "\n",
      "running with  rmsprop\n",
      "(Iteration 1 / 200) loss: 2.721876\n",
      "(Epoch 0 / 5) train acc: 0.096000; val_acc: 0.100000\n",
      "(Iteration 11 / 200) loss: 2.166712\n",
      "(Iteration 21 / 200) loss: 2.037393\n",
      "(Iteration 31 / 200) loss: 1.768814\n",
      "(Epoch 1 / 5) train acc: 0.370000; val_acc: 0.299000\n",
      "(Iteration 41 / 200) loss: 1.979791\n",
      "(Iteration 51 / 200) loss: 1.680587\n",
      "(Iteration 61 / 200) loss: 1.714828\n",
      "(Iteration 71 / 200) loss: 1.828746\n",
      "(Epoch 2 / 5) train acc: 0.425000; val_acc: 0.335000\n",
      "(Iteration 81 / 200) loss: 1.697653\n",
      "(Iteration 91 / 200) loss: 1.649901\n",
      "(Iteration 101 / 200) loss: 1.665087\n",
      "(Iteration 111 / 200) loss: 1.517468\n",
      "(Epoch 3 / 5) train acc: 0.482000; val_acc: 0.332000\n",
      "(Iteration 121 / 200) loss: 1.533694\n",
      "(Iteration 131 / 200) loss: 1.549660\n",
      "(Iteration 141 / 200) loss: 1.339872\n",
      "(Iteration 151 / 200) loss: 1.432987\n",
      "(Epoch 4 / 5) train acc: 0.508000; val_acc: 0.357000\n",
      "(Iteration 161 / 200) loss: 1.624018\n",
      "(Iteration 171 / 200) loss: 1.519794\n",
      "(Iteration 181 / 200) loss: 1.380878\n",
      "(Iteration 191 / 200) loss: 1.265176\n",
      "(Epoch 5 / 5) train acc: 0.557000; val_acc: 0.364000\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = {'rmsprop': 1e-4, 'adam': 1e-3}\n",
    "for update_rule in ['adam', 'rmsprop']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': learning_rates[update_rule]\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in list(solvers.items()):\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 3:\n",
    "\n",
    "AdaGrad, like Adam, is a per-parameter optimization method that uses the following update rule:\n",
    "\n",
    "```\n",
    "cache += dw**2\n",
    "w += - learning_rate * dw / (np.sqrt(cache) + eps)\n",
    "```\n",
    "\n",
    "John notices that when he was training a network with AdaGrad that the updates became very small, and that his network was learning slowly. Using your knowledge of the AdaGrad update rule, why do you think the updates would become very small? Would Adam have the same issue?\n",
    "\n",
    "\n",
    "## Answer: \n",
    "\n",
    "学习率是单调递减的，训练后期学习率过小会导致训练困难，甚至提前结束\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a good model!\n",
    "Train the best fully-connected model that you can on CIFAR-10, storing your best model in the `best_model` variable. We require you to get at least 50% accuracy on the validation set using a fully-connected net.\n",
    "\n",
    "If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.\n",
    "\n",
    "You might find it useful to complete the `BatchNormalization.ipynb` and `Dropout.ipynb` notebooks before completing this part, since those techniques can help you train powerful models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 4900) loss: 2.302586\n",
      "(Epoch 0 / 10) train acc: 0.088000; val_acc: 0.117000\n",
      "(Epoch 1 / 10) train acc: 0.461000; val_acc: 0.445000\n",
      "(Epoch 2 / 10) train acc: 0.529000; val_acc: 0.486000\n",
      "(Epoch 3 / 10) train acc: 0.535000; val_acc: 0.516000\n",
      "(Epoch 4 / 10) train acc: 0.594000; val_acc: 0.522000\n",
      "(Epoch 5 / 10) train acc: 0.636000; val_acc: 0.534000\n",
      "(Epoch 6 / 10) train acc: 0.619000; val_acc: 0.529000\n",
      "(Epoch 7 / 10) train acc: 0.631000; val_acc: 0.524000\n",
      "(Epoch 8 / 10) train acc: 0.670000; val_acc: 0.553000\n",
      "(Epoch 9 / 10) train acc: 0.703000; val_acc: 0.554000\n",
      "(Epoch 10 / 10) train acc: 0.711000; val_acc: 0.530000\n",
      "for lr: 1.000000e-04, reg: 0.000000e+00, ws: 1.000000e-03: valid accuracy is: 0.554000\n",
      "(Iteration 1 / 4900) loss: 2.302548\n",
      "(Epoch 0 / 10) train acc: 0.161000; val_acc: 0.168000\n",
      "(Epoch 1 / 10) train acc: 0.469000; val_acc: 0.469000\n",
      "(Epoch 2 / 10) train acc: 0.545000; val_acc: 0.514000\n",
      "(Epoch 3 / 10) train acc: 0.589000; val_acc: 0.536000\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-73-99371f9c469c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     33\u001b[0m                     \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     34\u001b[0m                     print_every=10000000)\n\u001b[0;32m---> 35\u001b[0;31m     \u001b[0msolver\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     36\u001b[0m     \u001b[0mval_acc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msolver\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbest_val_acc\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     37\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/Documents/cs231n/assignment2/cs231n/solver.py\u001b[0m in \u001b[0;36mtrain\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    264\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    265\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnum_iterations\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 266\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    267\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    268\u001b[0m             \u001b[0;31m# Maybe print training loss\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/Documents/cs231n/assignment2/cs231n/solver.py\u001b[0m in \u001b[0;36m_step\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    187\u001b[0m             \u001b[0mdw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgrads\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mp\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    188\u001b[0m             \u001b[0mconfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptim_configs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mp\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 189\u001b[0;31m             \u001b[0mnext_w\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnext_config\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate_rule\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mw\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdw\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    190\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mp\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnext_w\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    191\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptim_configs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mp\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnext_config\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/Documents/cs231n/assignment2/cs231n/optim.py\u001b[0m in \u001b[0;36madam\u001b[0;34m(w, dw, config)\u001b[0m\n\u001b[1;32m    152\u001b[0m     \u001b[0;31m# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    153\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 154\u001b[0;31m     \u001b[0mconfig\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'm'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconfig\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'beta1'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'm'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'beta1'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mdw\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    155\u001b[0m     \u001b[0mconfig\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'v'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconfig\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'beta2'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'v'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'beta2'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdw\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    156\u001b[0m     \u001b[0mnext_w\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mw\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mconfig\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'learning_rate'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mconfig\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'm'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'v'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mconfig\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'epsilon'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "best_model = None\n",
    "################################################################################\n",
    "# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #\n",
    "# find batch/layer normalization and dropout useful. Store your best model in  #\n",
    "# the best_model variable.                                                     #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "best_acc = -1\n",
    "for i in range(10):\n",
    "    lr = 1e-4  #np.random.uniform(1e-4, 1e-5)\n",
    "    ws = 1e-3  # np.random.uniform(1e-4, 1e-2)\n",
    "    rg = 1e-3   # np.random.uniform(1e-5, 1e-3)\n",
    "    \n",
    "    model = FullyConnectedNet([500, 100], weight_scale=ws, reg=rg)\n",
    "    solver = Solver(model, data,\n",
    "                    num_epochs=10, batch_size=100, # 200\n",
    "                    update_rule='adam',\n",
    "                    optim_config={\n",
    "                    'learning_rate': lr,\n",
    "                    },\n",
    "                    verbose=True,\n",
    "                    print_every=100)\n",
    "    solver.train()\n",
    "    val_acc = solver.best_val_acc\n",
    "    \n",
    "    print('for lr: %e, reg: %e, ws: %e: valid accuracy is: %f' % (lr, rg, ws, val_acc))\n",
    "    if best_acc < val_acc:\n",
    "        best_acc = val_acc\n",
    "        best_model = model\n",
    "\n",
    "# print best\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test your model!\n",
    "Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation set accuracy:  0.554\n",
      "Test set accuracy:  0.532\n"
     ]
    }
   ],
   "source": [
    "y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n",
    "y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n",
    "print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())\n",
    "print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
